< Summary

Class:GDX.Tables.StableTable
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs
Covered lines:0
Uncovered lines:1172
Coverable lines:1172
Total lines:1785
Line coverage:0% (0 of 1172)
Covered branches:0
Total branches:0
Covered methods:0
Total methods:164
Method coverage:0% (0 of 164)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
StableTable()0%2100%
GetDataVersion()0%2100%
GetColumnCount()0%2100%
GetRowCount()0%2100%
GetDisplayName()0%2100%
SetDisplayName(...)0%2100%
GetFlag(...)0%2100%
SetFlag(...)0%2100%
GetAllRowDescriptions()0%20400%
GetRowDescription(...)0%12300%
GetRowDescription(...)0%2100%
SetAllRowDescriptionsOrder(...)0%2100%
GetColumnDescription(...)0%30500%
GetColumnDescription(...)0%2100%
SetAllColumnDescriptionsOrder(...)0%2100%
GetAllColumnDescriptions()0%12300%
AssertColumnIDValid(...)0%20400%
AssertRowIDValid(...)0%30500%
SetColumnName(...)0%2100%
GetColumnName(...)0%2100%
SetRowName(...)0%2100%
GetRowName(...)0%2100%
GetRowNameRef(...)0%2100%
GetColumnNameRef(...)0%2100%
AddRow(...)0%2401500%
AddRows(...)0%4202000%
AddRows(...)0%4202000%
RemoveRow(...)0%6200%
AddColumn(...)0%9923100%
RemoveColumn(...)0%9303000%
SetString(...)0%2100%
SetBool(...)0%2100%
SetChar(...)0%2100%
SetSByte(...)0%2100%
SetByte(...)0%2100%
SetShort(...)0%2100%
SetUShort(...)0%2100%
SetInt(...)0%2100%
SetUInt(...)0%2100%
SetLong(...)0%2100%
SetULong(...)0%2100%
SetFloat(...)0%2100%
SetDouble(...)0%2100%
SetVector2(...)0%2100%
SetVector3(...)0%2100%
SetVector4(...)0%2100%
SetVector2Int(...)0%2100%
SetVector3Int(...)0%2100%
SetQuaternion(...)0%2100%
SetRect(...)0%2100%
SetRectInt(...)0%2100%
SetColor(...)0%2100%
SetLayerMask(...)0%2100%
SetBounds(...)0%2100%
SetBoundsInt(...)0%2100%
SetHash128(...)0%2100%
SetGradient(...)0%2100%
SetAnimationCurve(...)0%2100%
SetObject(...)0%2100%
GetString(...)0%2100%
GetBool(...)0%2100%
GetChar(...)0%2100%
GetSByte(...)0%2100%
GetByte(...)0%2100%
GetShort(...)0%2100%
GetUShort(...)0%2100%
GetInt(...)0%2100%
GetUInt(...)0%2100%
GetLong(...)0%2100%
GetULong(...)0%2100%
GetFloat(...)0%2100%
GetDouble(...)0%2100%
GetVector2(...)0%2100%
GetVector3(...)0%2100%
GetVector4(...)0%2100%
GetVector2Int(...)0%2100%
GetVector3Int(...)0%2100%
GetQuaternion(...)0%2100%
GetRect(...)0%2100%
GetRectInt(...)0%2100%
GetColor(...)0%2100%
GetLayerMask(...)0%2100%
GetBounds(...)0%2100%
GetBoundsInt(...)0%2100%
GetHash128(...)0%2100%
GetGradient(...)0%2100%
GetAnimationCurve(...)0%2100%
GetObject(...)0%2100%
GetStringRef(...)0%2100%
GetBoolRef(...)0%2100%
GetCharRef(...)0%2100%
GetSbyteRef(...)0%2100%
GetByteRef(...)0%2100%
GetShortRef(...)0%2100%
GetUshortRef(...)0%2100%
GetIntRef(...)0%2100%
GetUintRef(...)0%2100%
GetLongRef(...)0%2100%
GetUlongRef(...)0%2100%
GetFloatRef(...)0%2100%
GetDoubleRef(...)0%2100%
GetVector2Ref(...)0%2100%
GetVector3Ref(...)0%2100%
GetVector4Ref(...)0%2100%
GetVector2IntRef(...)0%2100%
GetVector3IntRef(...)0%2100%
GetQuaternionRef(...)0%2100%
GetRectRef(...)0%2100%
GetRectIntRef(...)0%2100%
GetColorRef(...)0%2100%
GetLayerMaskRef(...)0%2100%
GetBoundsRef(...)0%2100%
GetBoundsIntRef(...)0%2100%
GetHash128Ref(...)0%2100%
GetGradientRef(...)0%2100%
GetAnimationCurveRef(...)0%2100%
GetObjectRef(...)0%2100%
GetStringColumn(...)0%2100%
GetBoolColumn(...)0%2100%
GetCharColumn(...)0%2100%
GetSbyteColumn(...)0%2100%
GetByteColumn(...)0%2100%
GetShortColumn(...)0%2100%
GetUshortColumn(...)0%2100%
GetIntColumn(...)0%2100%
GetUintColumn(...)0%2100%
GetLongColumn(...)0%2100%
GetUlongColumn(...)0%2100%
GetFloatColumn(...)0%2100%
GetDoubleColumn(...)0%2100%
GetVector2Column(...)0%2100%
GetVector3Column(...)0%2100%
GetVector4Column(...)0%2100%
GetVector2IntColumn(...)0%2100%
GetVector3IntColumn(...)0%2100%
GetQuaternionColumn(...)0%2100%
GetRectColumn(...)0%2100%
GetRectIntColumn(...)0%2100%
GetColorColumn(...)0%2100%
GetLayerMaskColumn(...)0%2100%
GetBoundsColumn(...)0%2100%
GetBoundsIntColumn(...)0%2100%
GetHash128Column(...)0%2100%
GetGradientColumn(...)0%2100%
GetAnimationCurveColumn(...)0%2100%
GetObjectColumn(...)0%2100%
SetColumnOrder(...)0%20400%
SetAllColumnOrders(...)0%6200%
SetRowOrder(...)0%20400%
SetAllRowOrders(...)0%6200%
ReSortRows[T](...)0%12300%
AddColumnInternal[T](...)0%4202000%
RemoveColumnInternal[T](...)0%6200%
InsertRowsOfTypeInternal[T](...)0%42600%
DeleteRowsOfTypeInternal[T](...)0%30500%
GetCellRef[T](...)0%2100%
GetCell[T](...)0%2100%
SetCell[T](...)0%2100%
GetColumn[T](...)0%2100%
SetRowOrderForColumns[T](...)0%30500%
AssertSortedColumnsArgValid(...)0%20400%
AssertColumnSortOrderValid(...)0%12300%
AssertRowSortOrderValid(...)0%12300%
AssertSorteRowsArgValid(...)0%20400%

File(s)

D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs

#LineLine coverage
 1// Copyright (c) 2020-2023 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using GDX.Collections;
 7using UnityEngine;
 8
 9namespace GDX.Tables
 10{
 11
 12    [CreateAssetMenu(menuName = "GDX/Stable Table", fileName = "GDXStableTable")]
 13    [Serializable]
 14    public class StableTable : ScriptableObject, ITable
 15    {
 16
 17        [Serializable]
 18        internal struct ColumnEntry
 19        {
 20            public Serializable.SerializableTypes ColumnType;
 21            public int columnDenseIndex;
 22        }
 23
 024        [SerializeField] internal string m_DisplayName = "GDXStableTable";
 25
 26        [SerializeField] internal ArrayHolder<string>[] allStringColumns;
 27        [SerializeField] internal ArrayHolder<bool>[] allBoolColumns;
 28        [SerializeField] internal ArrayHolder<char>[] allCharColumns;
 29        [SerializeField] internal ArrayHolder<sbyte>[] allSbyteColumns;
 30        [SerializeField] internal ArrayHolder<byte>[] allByteColumns;
 31        [SerializeField] internal ArrayHolder<short>[] allShortColumns;
 32        [SerializeField] internal ArrayHolder<ushort>[] allUshortColumns;
 33        [SerializeField] internal ArrayHolder<int>[] allIntColumns;
 34        [SerializeField] internal ArrayHolder<uint>[] allUintColumns;
 35        [SerializeField] internal ArrayHolder<long>[] allLongColumns;
 36        [SerializeField] internal ArrayHolder<ulong>[] allUlongColumns;
 37        [SerializeField] internal ArrayHolder<float>[] allFloatColumns;
 38        [SerializeField] internal ArrayHolder<double>[] allDoubleColumns;
 39        [SerializeField] internal ArrayHolder<Vector2>[] allVector2Columns;
 40        [SerializeField] internal ArrayHolder<Vector3>[] allVector3Columns;
 41        [SerializeField] internal ArrayHolder<Vector4>[] allVector4Columns;
 42        [SerializeField] internal ArrayHolder<Vector2Int>[] allVector2IntColumns;
 43        [SerializeField] internal ArrayHolder<Vector3Int>[] allVector3IntColumns;
 44        [SerializeField] internal ArrayHolder<Quaternion>[] allQuaternionColumns;
 45        [SerializeField] internal ArrayHolder<Rect>[] allRectColumns;
 46        [SerializeField] internal ArrayHolder<RectInt>[] allRectIntColumns;
 47        [SerializeField] internal ArrayHolder<Color>[] allColorColumns;
 48        [SerializeField] internal ArrayHolder<LayerMask>[] allLayerMaskColumns;
 49        [SerializeField] internal ArrayHolder<Bounds>[] allBoundsColumns;
 50        [SerializeField] internal ArrayHolder<BoundsInt>[] allBoundsIntColumns;
 51        [SerializeField] internal ArrayHolder<Hash128>[] allHash128Columns;
 52        [SerializeField] internal ArrayHolder<Gradient>[] allGradientColumns;
 53        [SerializeField] internal ArrayHolder<AnimationCurve>[] allAnimationCurveColumns;
 54        [SerializeField] internal ArrayHolder<UnityEngine.Object>[] allObjectRefColumns;
 055        [SerializeField] internal ArrayHolder<string>[] allColumnNames = new ArrayHolder<string>[Serializable.Serializab
 56
 57        [SerializeField] internal int[] rowIDToDenseIndexMap;
 58        [SerializeField] internal int[] rowDenseIndexToIDMap;
 59        [SerializeField] internal string[] rowNames;
 60        [SerializeField] internal int rowEntriesFreeListHead;
 61
 62        [SerializeField]
 63        internal int rowCount;
 64
 65        [SerializeField] internal ColumnEntry[] columnIDToDenseIndexMap;
 66        [SerializeField] internal int[] columnIDToSortOrderMap;
 67        [SerializeField] internal int[] sortedOrderToColumnIDMap;
 68
 69        // TODO move with other block
 070        [SerializeField] ArrayHolder<int>[] columnDenseIndexToIDMap = new ArrayHolder<int>[Serializable.SerializableType
 71
 72        [SerializeField]
 73        internal int columnEntriesFreeListHead;
 74
 75        [SerializeField]
 76        internal int combinedColumnCount;
 77
 78        [SerializeField]
 079        internal ulong dataVersion = 1;
 80
 81        [SerializeField] BitArray8 m_Flags;
 82
 83        public ulong GetDataVersion()
 084        {
 085            return dataVersion;
 086        }
 87
 88        /// <inheritdoc />
 89        public int GetColumnCount()
 090        {
 091            return combinedColumnCount;
 092        }
 93
 94        /// <inheritdoc />
 95        public int GetRowCount()
 096        {
 097            return rowCount;
 098        }
 99
 100        public string GetDisplayName()
 0101        {
 0102            return m_DisplayName;
 0103        }
 104
 105        public void SetDisplayName(string displayName)
 0106        {
 0107            m_DisplayName = displayName;
 0108        }
 109
 110        public bool GetFlag(byte index)
 0111        {
 0112            return m_Flags[index];
 0113        }
 114
 115        public void SetFlag(byte index, bool toggle)
 0116        {
 0117            m_Flags[index] = toggle;
 0118        }
 119
 120        public ITable.RowDescription[] GetAllRowDescriptions()
 0121        {
 0122            if (combinedColumnCount == 0 || rowCount == 0) return null;
 0123            ITable.RowDescription[] returnArray = new ITable.RowDescription[rowCount];
 0124            string empty = string.Empty;
 0125            for (int i = 0; i < rowCount; i++)
 0126            {
 0127                returnArray[i].InternalIndex = rowDenseIndexToIDMap[i];
 0128                returnArray[i].Name = rowNames[i];
 0129            }
 130
 0131            return returnArray;
 0132        }
 133        public ITable.RowDescription GetRowDescription(string name)
 0134        {
 0135            for (int i = 0; i < rowCount; i++)
 0136            {
 0137                string nameAt = rowNames[i];
 138
 0139                if (nameAt == name)
 0140                {
 0141                    return new ITable.RowDescription
 142                    {
 143                        InternalIndex = rowDenseIndexToIDMap[i],
 144                        Name = nameAt,
 145                    };
 146                }
 0147            }
 148
 0149            throw new ArgumentException("Row with name " + name + " does not exist in the table");
 0150        }
 151
 152        public ITable.RowDescription GetRowDescription(int order)
 0153        {
 0154            return new ITable.RowDescription
 155            {
 156                InternalIndex = rowDenseIndexToIDMap[order],
 157                Name = rowNames[order],
 158            };
 0159        }
 160
 161        public void SetAllRowDescriptionsOrder(ITable.RowDescription[] orderedRows)
 0162        {
 163            // TODO: @adam array coming in be in the new order, just use the internalIndex (stable to reorder inside her
 0164            throw new NotImplementedException();
 165        }
 166
 167        public ITable.ColumnDescription GetColumnDescription(string name)
 0168        {
 0169            for (int i = 0; i < Serializable.SerializableTypesCount; i++)
 0170            {
 0171                string[] columnNames = allColumnNames[i].TArray;
 172
 0173                if (columnNames != null)
 0174                {
 0175                    for (int j = 0; j < columnNames.Length; j++)
 0176                    {
 0177                        string nameAt = columnNames[j];
 178
 0179                        if (name == nameAt)
 0180                        {
 0181                            int columnID = columnDenseIndexToIDMap[i].TArray[j];
 182
 0183                            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[columnID];
 0184                            return new ITable.ColumnDescription
 185                            {
 186                                InternalIndex = columnID,
 187                                Name = nameAt,
 188                                Type = columnEntry.ColumnType,
 189                            };
 190                        }
 0191                    }
 0192                }
 0193            }
 194
 0195            throw new ArgumentException("Column with name " + name + " does not exist in the table");
 0196        }
 197
 198        public ITable.ColumnDescription GetColumnDescription(int order)
 0199        {
 0200            int idAtOrderedIndex = sortedOrderToColumnIDMap[order];
 0201            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[idAtOrderedIndex];
 202
 0203            string columnName = allColumnNames[(int)columnEntry.ColumnType][columnEntry.columnDenseIndex];
 204
 0205            return new ITable.ColumnDescription
 206            {
 207                InternalIndex = idAtOrderedIndex,
 208                Name = columnName,
 209                Type = columnEntry.ColumnType,
 210            };
 0211        }
 212
 213        public void SetAllColumnDescriptionsOrder(ITable.ColumnDescription[] orderedColumns)
 0214        {
 215            // TODO: @adam array coming in be in the new order, just use the internalIndex (stable to reorder inside her
 0216            throw new NotImplementedException();
 217        }
 218
 219        /// <inheritdoc />
 220        public ITable.ColumnDescription[] GetAllColumnDescriptions()
 0221        {
 0222            if (combinedColumnCount == 0) return null;
 0223            ITable.ColumnDescription[] returnArray = new ITable.ColumnDescription[combinedColumnCount];
 224
 0225            for (int i = 0; i < combinedColumnCount; i++)
 0226            {
 0227                int columnID = sortedOrderToColumnIDMap[i];
 0228                AssertColumnIDValid(columnID);
 0229                ref ColumnEntry entryForID = ref columnIDToDenseIndexMap[columnID];
 0230                ref ArrayHolder<string> nameColumnsForType = ref allColumnNames[(int)entryForID.ColumnType];
 231
 0232                string name = nameColumnsForType[entryForID.columnDenseIndex];
 233
 0234                returnArray[i] = new ITable.ColumnDescription
 235                {
 236                    Name = name,
 237                    InternalIndex = columnID,
 238                    Type = entryForID.ColumnType,
 239                };
 0240            }
 241
 0242            return returnArray;
 0243        }
 244
 245        internal void AssertColumnIDValid(int columnID)
 0246        {
 0247            if (columnID < 0 || columnID >= columnIDToDenseIndexMap.Length)
 0248            {
 0249                throw new ArgumentException("Invalid column outside valid ID range: " + columnID);
 250            }
 251
 0252            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[columnID];
 253
 0254            if (columnEntry.ColumnType == Serializable.SerializableTypes.Invalid)
 0255            {
 0256                throw new ArgumentException("Invalid column pointing to deallocated entry: " + columnID);
 257            }
 0258        }
 259
 260        internal void AssertRowIDValid(int rowID)
 0261        {
 0262            if (rowID < 0 || rowID >= rowIDToDenseIndexMap.Length)
 0263            {
 0264                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 265            }
 266
 0267            int rowIndex = rowIDToDenseIndexMap[rowID];
 268
 0269            if (rowIndex >= rowCount || rowIndex < 0)
 0270            {
 0271                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 272            }
 0273        }
 274
 275        public void SetColumnName(string columnName, int column)
 0276        {
 0277            AssertColumnIDValid(column);
 0278            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[column];
 0279            allColumnNames[(int)columnEntry.ColumnType][columnEntry.columnDenseIndex] = columnName;
 0280        }
 281
 282        public string GetColumnName(int column)
 0283        {
 0284            AssertColumnIDValid(column);
 0285            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[column];
 0286            return allColumnNames[(int)columnEntry.ColumnType][columnEntry.columnDenseIndex];
 0287        }
 288
 289        public void SetRowName(string rowName, int row)
 0290        {
 0291            AssertRowIDValid(row);
 0292            int rowDenseIndex = rowIDToDenseIndexMap[row];
 0293            rowNames[rowDenseIndex] = rowName;
 0294        }
 295
 296        public string GetRowName(int row)
 0297        {
 0298            AssertRowIDValid(row);
 0299            int rowDenseIndex = rowIDToDenseIndexMap[row];
 0300            return rowNames[rowDenseIndex];
 0301        }
 302
 303        public ref string GetRowNameRef(int row)
 0304        {
 0305            AssertRowIDValid(row);
 0306            int rowDenseIndex = rowIDToDenseIndexMap[row];
 0307            return ref rowNames[rowDenseIndex];
 0308        }
 309
 310        public ref string GetColumnNameRef(int columnID)
 0311        {
 0312            AssertColumnIDValid(columnID);
 0313            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[columnID];
 0314            return ref allColumnNames[(int)columnEntry.ColumnType][columnEntry.columnDenseIndex];
 0315        }
 316
 317
 318        public int AddRow(string rowName = null, int insertAtRowID = -1)
 0319        {
 0320            if (insertAtRowID >= 0)
 0321            {
 0322                AssertRowIDValid(insertAtRowID);
 0323            }
 0324            int rowID = rowEntriesFreeListHead;
 0325            int rowIDToDenseIndexMapLength = rowIDToDenseIndexMap?.Length ?? 0;
 0326            if (rowID >= rowIDToDenseIndexMapLength)
 0327            {
 0328                int newSize = rowID * 2;
 0329                newSize = newSize == 0 ? 1 : newSize;
 0330                Array.Resize(ref rowIDToDenseIndexMap, newSize);
 0331                for (int i = rowID; i < newSize; i++)
 0332                {
 0333                    rowIDToDenseIndexMap[i] = i + 1;
 0334                }
 0335            }
 336
 0337            int denseIndexToIDMapLength = rowDenseIndexToIDMap?.Length ?? 0;
 0338            Array.Resize(ref rowDenseIndexToIDMap, denseIndexToIDMapLength + 1);
 0339            Array.Resize(ref rowNames, denseIndexToIDMapLength + 1);
 340
 0341            int insertAt = insertAtRowID < 0 ? rowCount : rowIDToDenseIndexMap[insertAtRowID];
 342
 0343            for (int i = denseIndexToIDMapLength; i > insertAt; i--)
 0344            {
 0345                int currentRowID = rowDenseIndexToIDMap[i - 1];
 0346                rowDenseIndexToIDMap[i] = currentRowID;
 347
 0348                rowIDToDenseIndexMap[currentRowID] = i;
 349
 0350                rowNames[i] = rowNames[i - 1];
 0351            }
 352
 0353            rowEntriesFreeListHead = rowIDToDenseIndexMap[rowID];
 0354            rowIDToDenseIndexMap[rowID] = insertAt;
 0355            rowDenseIndexToIDMap[insertAt] = rowID;
 0356            rowNames[insertAt] = rowName == null ? rowID.ToString() : rowName;
 357
 0358            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, 1);
 0359            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, 1);
 0360            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, 1);
 0361            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, 1);
 0362            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, 1);
 0363            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, 1);
 0364            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, 1);
 0365            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, 1);
 0366            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, 1);
 0367            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, 1);
 0368            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, 1);
 0369            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, 1);
 0370            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, 1);
 0371            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, 1);
 0372            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, 1);
 0373            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, 1);
 0374            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, 1);
 0375            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, 1);
 0376            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, 1);
 0377            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, 1);
 0378            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, 1);
 0379            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, 1);
 0380            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, 1);
 0381            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, 1);
 0382            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, 1);
 0383            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, 1);
 0384            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, 1);
 0385            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, 1);
 0386            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, 1);
 387
 0388            ++rowCount;
 0389            dataVersion++;
 390
 0391            return rowID;
 0392        }
 393
 394        public void AddRows(int numberOfNewRows, string[] rowNames = null, int insertAtRowID = -1)
 0395        {
 0396            if (insertAtRowID >= 0)
 0397            {
 0398                AssertRowIDValid(insertAtRowID);
 0399            }
 0400            int rowIDToDenseIndexMapLength = rowIDToDenseIndexMap?.Length ?? 0;
 0401            int newCount = rowCount + numberOfNewRows;
 0402            if (newCount > rowIDToDenseIndexMapLength)
 0403            {
 0404                int newSize = newCount;
 0405                --newSize;
 0406                newSize |= newSize >> 1;
 0407                newSize |= newSize >> 2;
 0408                newSize |= newSize >> 4;
 0409                newSize |= newSize >> 8;
 0410                newSize |= newSize >> 16;
 0411                ++newSize;
 412
 0413                newSize = newSize == 0 ? 1 : newSize;
 0414                Array.Resize(ref rowIDToDenseIndexMap, newSize);
 0415                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0416                {
 0417                    rowIDToDenseIndexMap[i] = i + 1;
 0418                }
 0419            }
 420
 0421            int denseIndexToIDMapLength = rowDenseIndexToIDMap?.Length ?? 0;
 0422            Array.Resize(ref rowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 0423            Array.Resize(ref rowNames, denseIndexToIDMapLength + numberOfNewRows);
 424
 0425            int insertAt = insertAtRowID < 0 ? rowCount : rowIDToDenseIndexMap[insertAtRowID];
 426
 0427            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0428            {
 0429                int currentRowID = rowDenseIndexToIDMap[i - numberOfNewRows];
 0430                rowDenseIndexToIDMap[i] = currentRowID;
 431
 0432                rowIDToDenseIndexMap[currentRowID] = i;
 433
 0434                rowNames[i] = rowNames[i - numberOfNewRows];
 0435            }
 436
 0437            int freeListHead = rowEntriesFreeListHead;
 438
 0439            for (int i = 0; i < numberOfNewRows; i++)
 0440            {
 0441                int rowID = freeListHead;
 0442                freeListHead = rowIDToDenseIndexMap[rowID];
 0443                rowIDToDenseIndexMap[rowID] = insertAt + i;
 0444                rowDenseIndexToIDMap[insertAt + i] = rowID;
 0445            }
 446
 0447            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0448            string emptyString = string.Empty;
 0449            for (int i = 0; i < numberOfNewRowNames; i++)
 0450            {
 0451                string currentRowName = rowNames[i];
 0452                int rowIDAt = rowDenseIndexToIDMap[insertAt + i];
 0453                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0454            }
 455
 0456            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0457            {
 0458                int rowIDAt = rowDenseIndexToIDMap[insertAt + i];
 0459                rowNames[insertAt + i] = rowIDAt.ToString();
 0460            }
 461
 0462            rowEntriesFreeListHead = freeListHead;
 463
 0464            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, numberOfNewRows);
 0465            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, numberOfNewRows);
 0466            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, numberOfNewRows);
 0467            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, numberOfNewRows);
 0468            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, numberOfNewRows);
 0469            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, numberOfNewRows);
 0470            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, numberOfNewRows);
 0471            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, numberOfNewRows);
 0472            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, numberOfNewRows);
 0473            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, numberOfNewRows);
 0474            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, numberOfNewRows);
 0475            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, numberOfNewRows);
 0476            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, numberOfNewRows);
 0477            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, numberOfNewRows);
 0478            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, numberOfNewRows);
 0479            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, numberOfNewRows);
 0480            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, numberOfNewRows);
 0481            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, numberOfNewRows);
 0482            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, numberOfNewRows);
 0483            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, numberOfNewRows);
 0484            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, numberOfNewRows);
 0485            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, numberOfNewRows);
 0486            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, numberOfNewRows);
 0487            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, numberOfNewRows);
 0488            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, numberOfNewRows);
 0489            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, numberOfNewRows);
 0490            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, numberOfNewRows);
 0491            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, numberOfNewRows);
 0492            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, numberOfNewRows);
 493
 0494            rowCount += numberOfNewRows;
 0495            dataVersion++;
 0496        }
 497
 498        public void AddRows(int numberOfNewRows, ref int[] rowIDs, string[] rowNames = null, int insertAtRowID = -1)
 0499        {
 0500            if (insertAtRowID >= 0)
 0501            {
 0502                AssertRowIDValid(insertAtRowID);
 0503            }
 0504            int rowIDToDenseIndexMapLength = rowIDToDenseIndexMap?.Length ?? 0;
 0505            int newCount = rowCount + numberOfNewRows;
 0506            if (newCount > rowIDToDenseIndexMapLength)
 0507            {
 0508                int newSize = newCount;
 0509                --newSize;
 0510                newSize |= newSize >> 1;
 0511                newSize |= newSize >> 2;
 0512                newSize |= newSize >> 4;
 0513                newSize |= newSize >> 8;
 0514                newSize |= newSize >> 16;
 0515                ++newSize;
 516
 0517                newSize = newSize == 0 ? 1 : newSize;
 0518                Array.Resize(ref rowIDToDenseIndexMap, newSize);
 0519                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0520                {
 0521                    rowIDToDenseIndexMap[i] = i + 1;
 0522                }
 0523            }
 524
 0525            int denseIndexToIDMapLength = rowDenseIndexToIDMap?.Length ?? 0;
 0526            Array.Resize(ref rowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 527
 0528            int insertAt = insertAtRowID < 0 ? rowCount : rowIDToDenseIndexMap[insertAtRowID];
 529
 0530            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0531            {
 0532                int currentRowID = rowDenseIndexToIDMap[i - numberOfNewRows];
 0533                rowDenseIndexToIDMap[i] = currentRowID;
 534
 0535                rowIDToDenseIndexMap[currentRowID] = i;
 536
 0537                rowNames[i] = rowNames[i - numberOfNewRows];
 0538            }
 539
 0540            int freeListHead = rowEntriesFreeListHead;
 541
 0542            for (int i = 0; i < numberOfNewRows; i++)
 0543            {
 0544                int rowID = freeListHead;
 0545                freeListHead = rowIDToDenseIndexMap[rowID];
 0546                rowIDToDenseIndexMap[rowID] = insertAt + i;
 0547                rowDenseIndexToIDMap[insertAt + i] = rowID;
 0548                rowIDs[i] = rowID;
 0549            }
 550
 0551            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0552            for (int i = 0; i < numberOfNewRowNames; i++)
 0553            {
 0554                string currentRowName = rowNames[i];
 0555                int rowIDAt = rowDenseIndexToIDMap[insertAt + i];
 0556                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0557            }
 558
 0559            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0560            {
 0561                int rowIDAt = rowDenseIndexToIDMap[insertAt + i];
 0562                rowNames[insertAt + i] = rowIDAt.ToString();
 0563            }
 564
 0565            rowEntriesFreeListHead = freeListHead;
 566
 0567            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, numberOfNewRows);
 0568            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, numberOfNewRows);
 0569            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, numberOfNewRows);
 0570            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, numberOfNewRows);
 0571            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, numberOfNewRows);
 0572            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, numberOfNewRows);
 0573            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, numberOfNewRows);
 0574            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, numberOfNewRows);
 0575            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, numberOfNewRows);
 0576            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, numberOfNewRows);
 0577            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, numberOfNewRows);
 0578            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, numberOfNewRows);
 0579            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, numberOfNewRows);
 0580            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, numberOfNewRows);
 0581            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, numberOfNewRows);
 0582            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, numberOfNewRows);
 0583            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, numberOfNewRows);
 0584            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, numberOfNewRows);
 0585            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, numberOfNewRows);
 0586            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, numberOfNewRows);
 0587            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, numberOfNewRows);
 0588            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, numberOfNewRows);
 0589            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, numberOfNewRows);
 0590            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, numberOfNewRows);
 0591            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, numberOfNewRows);
 0592            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, numberOfNewRows);
 0593            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, numberOfNewRows);
 0594            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, numberOfNewRows);
 0595            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, numberOfNewRows);
 596
 0597            rowCount += numberOfNewRows;
 0598            dataVersion++;
 0599        }
 600
 601        public void RemoveRow(int rowID)
 0602        {
 0603            AssertRowIDValid(rowID);
 0604            int rowDenseIndex = rowIDToDenseIndexMap[rowID];
 0605            for (int i = rowDenseIndex + 1; i < rowCount; i++)
 0606            {
 0607                int currentRowID = rowDenseIndexToIDMap[i];
 0608                rowIDToDenseIndexMap[currentRowID] = i - 1;
 0609                rowDenseIndexToIDMap[i - 1] = currentRowID;
 0610                rowNames[i - 1] = rowNames[i];
 0611            }
 612
 0613            rowIDToDenseIndexMap[rowID] = rowEntriesFreeListHead;
 0614            rowEntriesFreeListHead = rowID;
 0615            Array.Resize(ref rowDenseIndexToIDMap, rowCount - 1);
 0616            Array.Resize(ref rowNames, rowCount - 1);
 617
 0618            DeleteRowsOfTypeInternal(ref allStringColumns, rowID, 1);
 0619            DeleteRowsOfTypeInternal(ref allBoolColumns, rowID, 1);
 0620            DeleteRowsOfTypeInternal(ref allCharColumns, rowID, 1);
 0621            DeleteRowsOfTypeInternal(ref allSbyteColumns, rowID, 1);
 0622            DeleteRowsOfTypeInternal(ref allByteColumns, rowID, 1);
 0623            DeleteRowsOfTypeInternal(ref allShortColumns, rowID, 1);
 0624            DeleteRowsOfTypeInternal(ref allUshortColumns, rowID, 1);
 0625            DeleteRowsOfTypeInternal(ref allIntColumns, rowID, 1);
 0626            DeleteRowsOfTypeInternal(ref allUintColumns, rowID, 1);
 0627            DeleteRowsOfTypeInternal(ref allLongColumns, rowID, 1);
 0628            DeleteRowsOfTypeInternal(ref allUlongColumns, rowID, 1);
 0629            DeleteRowsOfTypeInternal(ref allFloatColumns, rowID, 1);
 0630            DeleteRowsOfTypeInternal(ref allDoubleColumns, rowID, 1);
 0631            DeleteRowsOfTypeInternal(ref allVector2Columns, rowID, 1);
 0632            DeleteRowsOfTypeInternal(ref allVector3Columns, rowID, 1);
 0633            DeleteRowsOfTypeInternal(ref allVector4Columns, rowID, 1);
 0634            DeleteRowsOfTypeInternal(ref allVector2IntColumns, rowID, 1);
 0635            DeleteRowsOfTypeInternal(ref allVector3IntColumns, rowID, 1);
 0636            DeleteRowsOfTypeInternal(ref allQuaternionColumns, rowID, 1);
 0637            DeleteRowsOfTypeInternal(ref allRectColumns, rowID, 1);
 0638            DeleteRowsOfTypeInternal(ref allRectIntColumns, rowID, 1);
 0639            DeleteRowsOfTypeInternal(ref allColorColumns, rowID, 1);
 0640            DeleteRowsOfTypeInternal(ref allLayerMaskColumns, rowID, 1);
 0641            DeleteRowsOfTypeInternal(ref allBoundsColumns, rowID, 1);
 0642            DeleteRowsOfTypeInternal(ref allBoundsIntColumns, rowID, 1);
 0643            DeleteRowsOfTypeInternal(ref allHash128Columns, rowID, 1);
 0644            DeleteRowsOfTypeInternal(ref allGradientColumns, rowID, 1);
 0645            DeleteRowsOfTypeInternal(ref allAnimationCurveColumns, rowID, 1);
 0646            DeleteRowsOfTypeInternal(ref allObjectRefColumns, rowID, 1);
 647
 0648            --rowCount;
 0649            dataVersion++;
 0650        }
 651
 652        public int AddColumn(Serializable.SerializableTypes columnType, string columnName, int insertAtColumnID = -1)
 0653        {
 0654            switch (columnType)
 655            {
 656                case Serializable.SerializableTypes.String:
 0657                    return AddColumnInternal(columnName, ref allStringColumns, Serializable.SerializableTypes.String, in
 658                case Serializable.SerializableTypes.Char:
 0659                    return AddColumnInternal(columnName, ref allCharColumns, Serializable.SerializableTypes.Char, insert
 660                case Serializable.SerializableTypes.Bool:
 0661                    return AddColumnInternal(columnName, ref allBoolColumns, Serializable.SerializableTypes.Bool, insert
 662                case Serializable.SerializableTypes.SByte:
 0663                    return AddColumnInternal(columnName, ref allSbyteColumns, Serializable.SerializableTypes.SByte, inse
 664                case Serializable.SerializableTypes.Byte:
 0665                    return AddColumnInternal(columnName, ref allByteColumns, Serializable.SerializableTypes.Byte, insert
 666                case Serializable.SerializableTypes.Short:
 0667                    return AddColumnInternal(columnName, ref allShortColumns, Serializable.SerializableTypes.Short, inse
 668                case Serializable.SerializableTypes.UShort:
 0669                    return AddColumnInternal(columnName, ref allUshortColumns, Serializable.SerializableTypes.UShort, in
 670                case Serializable.SerializableTypes.Int:
 0671                    return AddColumnInternal(columnName, ref allIntColumns, Serializable.SerializableTypes.Int, insertAt
 672                case Serializable.SerializableTypes.UInt:
 0673                    return AddColumnInternal(columnName, ref allUintColumns, Serializable.SerializableTypes.UInt, insert
 674                case Serializable.SerializableTypes.Long:
 0675                    return AddColumnInternal(columnName, ref allLongColumns, Serializable.SerializableTypes.Long, insert
 676                case Serializable.SerializableTypes.ULong:
 0677                    return AddColumnInternal(columnName, ref allUlongColumns, Serializable.SerializableTypes.ULong, inse
 678                case Serializable.SerializableTypes.Float:
 0679                    return AddColumnInternal(columnName, ref allFloatColumns, Serializable.SerializableTypes.Float, inse
 680                case Serializable.SerializableTypes.Double:
 0681                    return AddColumnInternal(columnName, ref allDoubleColumns, Serializable.SerializableTypes.Double, in
 682                case Serializable.SerializableTypes.Vector2:
 0683                    return AddColumnInternal(columnName, ref allVector2Columns, Serializable.SerializableTypes.Vector2, 
 684                case Serializable.SerializableTypes.Vector3:
 0685                    return AddColumnInternal(columnName, ref allVector3Columns, Serializable.SerializableTypes.Vector3, 
 686                case Serializable.SerializableTypes.Vector4:
 0687                    return AddColumnInternal(columnName, ref allVector4Columns, Serializable.SerializableTypes.Vector4, 
 688                case Serializable.SerializableTypes.Vector2Int:
 0689                    return AddColumnInternal(columnName, ref allVector2IntColumns, Serializable.SerializableTypes.Vector
 690                case Serializable.SerializableTypes.Vector3Int:
 0691                    return AddColumnInternal(columnName, ref allVector3IntColumns, Serializable.SerializableTypes.Vector
 692                case Serializable.SerializableTypes.Quaternion:
 0693                    return AddColumnInternal(columnName, ref allQuaternionColumns, Serializable.SerializableTypes.Quater
 694                case Serializable.SerializableTypes.Rect:
 0695                    return AddColumnInternal(columnName, ref allRectColumns, Serializable.SerializableTypes.Rect, insert
 696                case Serializable.SerializableTypes.RectInt:
 0697                    return AddColumnInternal(columnName, ref allRectIntColumns, Serializable.SerializableTypes.RectInt, 
 698                case Serializable.SerializableTypes.Color:
 0699                    return AddColumnInternal(columnName, ref allColorColumns, Serializable.SerializableTypes.Color, inse
 700                case Serializable.SerializableTypes.LayerMask:
 0701                    return AddColumnInternal(columnName, ref allLayerMaskColumns, Serializable.SerializableTypes.LayerMa
 702                case Serializable.SerializableTypes.Bounds:
 0703                    return AddColumnInternal(columnName, ref allBoundsColumns, Serializable.SerializableTypes.Bounds, in
 704                case Serializable.SerializableTypes.BoundsInt:
 0705                    return AddColumnInternal(columnName, ref allBoundsIntColumns, Serializable.SerializableTypes.BoundsI
 706                case Serializable.SerializableTypes.Hash128:
 0707                    return AddColumnInternal(columnName, ref allHash128Columns, Serializable.SerializableTypes.Hash128, 
 708                case Serializable.SerializableTypes.Gradient:
 0709                    return AddColumnInternal(columnName, ref allGradientColumns, Serializable.SerializableTypes.Gradient
 710                case Serializable.SerializableTypes.AnimationCurve:
 0711                    return AddColumnInternal(columnName, ref allAnimationCurveColumns, Serializable.SerializableTypes.An
 712                case Serializable.SerializableTypes.Object:
 0713                    return AddColumnInternal(columnName, ref allObjectRefColumns, Serializable.SerializableTypes.Object,
 714            }
 0715            return -1;
 0716        }
 717
 718        public void RemoveColumn(Serializable.SerializableTypes columnType, int columnID)
 0719        {
 0720            switch (columnType)
 721            {
 722                case Serializable.SerializableTypes.String:
 0723                    RemoveColumnInternal(ref allStringColumns, Serializable.SerializableTypes.String, columnID);
 0724                    break;
 725                case Serializable.SerializableTypes.Char:
 0726                    RemoveColumnInternal(ref allCharColumns, Serializable.SerializableTypes.Char, columnID);
 0727                    break;
 728                case Serializable.SerializableTypes.Bool:
 0729                    RemoveColumnInternal(ref allBoolColumns, Serializable.SerializableTypes.Bool, columnID);
 0730                    break;
 731                case Serializable.SerializableTypes.SByte:
 0732                    RemoveColumnInternal(ref allSbyteColumns, Serializable.SerializableTypes.SByte, columnID);
 0733                    break;
 734                case Serializable.SerializableTypes.Byte:
 0735                    RemoveColumnInternal(ref allByteColumns, Serializable.SerializableTypes.Byte, columnID);
 0736                    break;
 737                case Serializable.SerializableTypes.Short:
 0738                    RemoveColumnInternal(ref allShortColumns, Serializable.SerializableTypes.Short, columnID);
 0739                    break;
 740                case Serializable.SerializableTypes.UShort:
 0741                    RemoveColumnInternal(ref allUshortColumns, Serializable.SerializableTypes.UShort, columnID);
 0742                    break;
 743                case Serializable.SerializableTypes.Int:
 0744                    RemoveColumnInternal(ref allIntColumns, Serializable.SerializableTypes.Int, columnID);
 0745                    break;
 746                case Serializable.SerializableTypes.UInt:
 0747                    RemoveColumnInternal(ref allUintColumns, Serializable.SerializableTypes.UInt, columnID);
 0748                    break;
 749                case Serializable.SerializableTypes.Long:
 0750                    RemoveColumnInternal(ref allLongColumns, Serializable.SerializableTypes.Long, columnID);
 0751                    break;
 752                case Serializable.SerializableTypes.ULong:
 0753                    RemoveColumnInternal(ref allUlongColumns, Serializable.SerializableTypes.ULong, columnID);
 0754                    break;
 755                case Serializable.SerializableTypes.Float:
 0756                    RemoveColumnInternal(ref allFloatColumns, Serializable.SerializableTypes.Float, columnID);
 0757                    break;
 758                case Serializable.SerializableTypes.Double:
 0759                    RemoveColumnInternal(ref allDoubleColumns, Serializable.SerializableTypes.Double, columnID);
 0760                    break;
 761                case Serializable.SerializableTypes.Vector2:
 0762                    RemoveColumnInternal(ref allVector2Columns, Serializable.SerializableTypes.Vector2, columnID);
 0763                    break;
 764                case Serializable.SerializableTypes.Vector3:
 0765                    RemoveColumnInternal(ref allVector3Columns, Serializable.SerializableTypes.Vector3, columnID);
 0766                    break;
 767                case Serializable.SerializableTypes.Vector4:
 0768                    RemoveColumnInternal(ref allVector4Columns, Serializable.SerializableTypes.Vector4, columnID);
 0769                    break;
 770                case Serializable.SerializableTypes.Vector2Int:
 0771                    RemoveColumnInternal(ref allVector2IntColumns, Serializable.SerializableTypes.Vector2Int, columnID);
 0772                    break;
 773                case Serializable.SerializableTypes.Vector3Int:
 0774                    RemoveColumnInternal(ref allVector3IntColumns, Serializable.SerializableTypes.Vector3Int, columnID);
 0775                    break;
 776                case Serializable.SerializableTypes.Quaternion:
 0777                    RemoveColumnInternal(ref allQuaternionColumns, Serializable.SerializableTypes.Quaternion, columnID);
 0778                    break;
 779                case Serializable.SerializableTypes.Rect:
 0780                    RemoveColumnInternal(ref allRectColumns, Serializable.SerializableTypes.Rect, columnID);
 0781                    break;
 782                case Serializable.SerializableTypes.RectInt:
 0783                    RemoveColumnInternal(ref allRectIntColumns, Serializable.SerializableTypes.RectInt, columnID);
 0784                    break;
 785                case Serializable.SerializableTypes.Color:
 0786                    RemoveColumnInternal(ref allColorColumns, Serializable.SerializableTypes.Color, columnID);
 0787                    break;
 788                case Serializable.SerializableTypes.LayerMask:
 0789                    RemoveColumnInternal(ref allLayerMaskColumns, Serializable.SerializableTypes.LayerMask, columnID);
 0790                    break;
 791                case Serializable.SerializableTypes.Bounds:
 0792                    RemoveColumnInternal(ref allBoundsColumns, Serializable.SerializableTypes.Bounds, columnID);
 0793                    break;
 794                case Serializable.SerializableTypes.BoundsInt:
 0795                    RemoveColumnInternal(ref allBoundsIntColumns, Serializable.SerializableTypes.BoundsInt, columnID);
 0796                    break;
 797                case Serializable.SerializableTypes.Hash128:
 0798                    RemoveColumnInternal(ref allHash128Columns, Serializable.SerializableTypes.Hash128, columnID);
 0799                    break;
 800                case Serializable.SerializableTypes.Gradient:
 0801                    RemoveColumnInternal(ref allGradientColumns, Serializable.SerializableTypes.Gradient, columnID);
 0802                    break;
 803                case Serializable.SerializableTypes.AnimationCurve:
 0804                    RemoveColumnInternal(ref allAnimationCurveColumns, Serializable.SerializableTypes.AnimationCurve, co
 0805                    break;
 806                case Serializable.SerializableTypes.Object:
 0807                    RemoveColumnInternal(ref allObjectRefColumns, Serializable.SerializableTypes.Object, columnID);
 0808                    break;
 809            }
 0810        }
 811
 812        // Set
 813
 814        public ulong SetString(int row, int column, string value)
 0815        {
 0816            return SetCell(row, column, ref allStringColumns, value);
 0817        }
 818
 819        public ulong SetBool(int row, int column, bool value)
 0820        {
 0821            return SetCell(row, column, ref allBoolColumns, value);
 0822        }
 823
 824        public ulong SetChar(int row, int column, char value)
 0825        {
 0826            return SetCell(row, column, ref allCharColumns, value);
 0827        }
 828
 829        public ulong SetSByte(int row, int column, sbyte value)
 0830        {
 0831            return SetCell(row, column, ref allSbyteColumns, value);
 0832        }
 833
 834        public ulong SetByte(int row, int column, byte value)
 0835        {
 0836            return SetCell(row, column, ref allByteColumns, value);
 0837        }
 838
 839        public ulong SetShort(int row, int column, short value)
 0840        {
 0841            return SetCell(row, column, ref allShortColumns, value);
 0842        }
 843
 844        public ulong SetUShort(int row, int column, ushort value)
 0845        {
 0846            return SetCell(row, column, ref allUshortColumns, value);
 0847        }
 848
 849        public ulong SetInt(int row, int column, int value)
 0850        {
 0851            return SetCell(row, column, ref allIntColumns, value);
 0852        }
 853
 854        public ulong SetUInt(int row, int column, uint value)
 0855        {
 0856            return SetCell(row, column, ref allUintColumns, value);
 0857        }
 858
 859        public ulong SetLong(int row, int column, long value)
 0860        {
 0861            return SetCell(row, column, ref allLongColumns, value);
 0862        }
 863
 864        public ulong SetULong(int row, int column, ulong value)
 0865        {
 0866            return SetCell(row, column, ref allUlongColumns, value);
 0867        }
 868
 869        public ulong SetFloat(int row, int column, float value)
 0870        {
 0871            return SetCell(row, column, ref allFloatColumns, value);
 0872        }
 873
 874        public ulong SetDouble(int row, int column, double value)
 0875        {
 0876            return SetCell(row, column, ref allDoubleColumns, value);
 0877        }
 878
 879        public ulong SetVector2(int row, int column, Vector2 value)
 0880        {
 0881            return SetCell(row, column, ref allVector2Columns, value);
 0882        }
 883
 884        public ulong SetVector3(int row, int column, Vector3 value)
 0885        {
 0886            return SetCell(row, column, ref allVector3Columns, value);
 0887        }
 888
 889        public ulong SetVector4(int row, int column, Vector4 value)
 0890        {
 0891            return SetCell(row, column, ref allVector4Columns, value);
 0892        }
 893
 894        public ulong SetVector2Int(int row, int column, Vector2Int value)
 0895        {
 0896            return SetCell(row, column, ref allVector2IntColumns, value);
 0897        }
 898
 899        public ulong SetVector3Int(int row, int column, Vector3Int value)
 0900        {
 0901            return SetCell(row, column, ref allVector3IntColumns, value);
 0902        }
 903
 904        public ulong SetQuaternion(int row, int column, Quaternion value)
 0905        {
 0906            return SetCell(row, column, ref allQuaternionColumns, value);
 0907        }
 908
 909        public ulong SetRect(int row, int column, Rect value)
 0910        {
 0911            return SetCell(row, column, ref allRectColumns, value);
 0912        }
 913
 914        public ulong SetRectInt(int row, int column, RectInt value)
 0915        {
 0916            return SetCell(row, column, ref allRectIntColumns, value);
 0917        }
 918
 919        public ulong SetColor(int row, int column, Color value)
 0920        {
 0921            return SetCell(row, column, ref allColorColumns, value);
 0922        }
 923
 924        public ulong SetLayerMask(int row, int column, LayerMask value)
 0925        {
 0926            return SetCell(row, column, ref allLayerMaskColumns, value);
 0927        }
 928
 929        public ulong SetBounds(int row, int column, Bounds value)
 0930        {
 0931            return SetCell(row, column, ref allBoundsColumns, value);
 0932        }
 933
 934        public ulong SetBoundsInt(int row, int column, BoundsInt value)
 0935        {
 0936            return SetCell(row, column, ref allBoundsIntColumns, value);
 0937        }
 938
 939        public ulong SetHash128(int row, int column, Hash128 value)
 0940        {
 0941            return SetCell(row, column, ref allHash128Columns, value);
 0942        }
 943
 944        public ulong SetGradient(int row, int column, Gradient value)
 0945        {
 0946            return SetCell(row, column, ref allGradientColumns, value);
 0947        }
 948
 949        public ulong SetAnimationCurve(int row, int column, AnimationCurve value)
 0950        {
 0951            return SetCell(row, column, ref allAnimationCurveColumns, value);
 0952        }
 953
 954        public ulong SetObject(int row, int column, UnityEngine.Object value)
 0955        {
 0956            return SetCell(row, column, ref allObjectRefColumns, value);
 0957        }
 958
 959        // Get
 960        public string GetString(int row, int column)
 0961        {
 0962            return GetCell(row, column, ref allStringColumns);
 0963        }
 964
 965        public bool GetBool(int row, int column)
 0966        {
 0967            return GetCell(row, column, ref allBoolColumns);
 0968        }
 969
 970        public char GetChar(int row, int column)
 0971        {
 0972            return GetCell(row, column, ref allCharColumns);
 0973        }
 974
 975        public sbyte GetSByte(int row, int column)
 0976        {
 0977            return GetCell(row, column, ref allSbyteColumns);
 0978        }
 979
 980        public byte GetByte(int row, int column)
 0981        {
 0982            return GetCell(row, column, ref allByteColumns);
 0983        }
 984
 985        public short GetShort(int row, int column)
 0986        {
 0987            return GetCell(row, column, ref allShortColumns);
 0988        }
 989
 990        public ushort GetUShort(int row, int column)
 0991        {
 0992            return GetCell(row, column, ref allUshortColumns);
 0993        }
 994
 995        public int GetInt(int row, int column)
 0996        {
 0997            return GetCell(row, column, ref allIntColumns);
 0998        }
 999
 1000        public uint GetUInt(int row, int column)
 01001        {
 01002            return GetCell(row, column, ref allUintColumns);
 01003        }
 1004
 1005        public long GetLong(int row, int column)
 01006        {
 01007            return GetCell(row, column, ref allLongColumns);
 01008        }
 1009
 1010        public ulong GetULong(int row, int column)
 01011        {
 01012            return GetCell(row, column, ref allUlongColumns);
 01013        }
 1014
 1015        public float GetFloat(int row, int column)
 01016        {
 01017            return GetCell(row, column, ref allFloatColumns);
 01018        }
 1019
 1020        public double GetDouble(int row, int column)
 01021        {
 01022            return GetCell(row, column, ref allDoubleColumns);
 01023        }
 1024
 1025        public Vector2 GetVector2(int row, int column)
 01026        {
 01027            return GetCell(row, column, ref allVector2Columns);
 01028        }
 1029
 1030        public Vector3 GetVector3(int row, int column)
 01031        {
 01032            return GetCell(row, column, ref allVector3Columns);
 01033        }
 1034
 1035        public Vector4 GetVector4(int row, int column)
 01036        {
 01037            return GetCell(row, column, ref allVector4Columns);
 01038        }
 1039
 1040        public Vector2Int GetVector2Int(int row, int column)
 01041        {
 01042            return GetCell(row, column, ref allVector2IntColumns);
 01043        }
 1044
 1045        public Vector3Int GetVector3Int(int row, int column)
 01046        {
 01047            return GetCell(row, column, ref allVector3IntColumns);
 01048        }
 1049
 1050        public Quaternion GetQuaternion(int row, int column)
 01051        {
 01052            return GetCell(row, column, ref allQuaternionColumns);
 01053        }
 1054
 1055        public Rect GetRect(int row, int column)
 01056        {
 01057            return GetCell(row, column, ref allRectColumns);
 01058        }
 1059
 1060        public RectInt GetRectInt(int row, int column)
 01061        {
 01062            return GetCell(row, column, ref allRectIntColumns);
 01063        }
 1064
 1065        public Color GetColor(int row, int column)
 01066        {
 01067            return GetCell(row, column, ref allColorColumns);
 01068        }
 1069
 1070        public LayerMask GetLayerMask(int row, int column)
 01071        {
 01072            return GetCell(row, column, ref allLayerMaskColumns);
 01073        }
 1074
 1075        public Bounds GetBounds(int row, int column)
 01076        {
 01077            return GetCell(row, column, ref allBoundsColumns);
 01078        }
 1079
 1080        public BoundsInt GetBoundsInt(int row, int column)
 01081        {
 01082            return GetCell(row, column, ref allBoundsIntColumns);
 01083        }
 1084
 1085        public Hash128 GetHash128(int row, int column)
 01086        {
 01087            return GetCell(row, column, ref allHash128Columns);
 01088        }
 1089
 1090        public Gradient GetGradient(int row, int column)
 01091        {
 01092            return GetCell(row, column, ref allGradientColumns);
 01093        }
 1094
 1095        public AnimationCurve GetAnimationCurve(int row, int column)
 01096        {
 01097            return GetCell(row, column, ref allAnimationCurveColumns);
 01098        }
 1099
 1100        public UnityEngine.Object GetObject(int row, int column)
 01101        {
 01102            return GetCell(row, column, ref allObjectRefColumns);
 01103        }
 1104
 1105        // Get ref
 1106
 1107        public ref string GetStringRef(int row, int column)
 01108        {
 01109            return ref GetCellRef(row, column, ref allStringColumns);
 01110        }
 1111
 1112        public ref bool GetBoolRef(int row, int column)
 01113        {
 01114            return ref GetCellRef(row, column, ref allBoolColumns);
 01115        }
 1116
 1117        public ref char GetCharRef(int row, int column)
 01118        {
 01119            return ref GetCellRef(row, column, ref allCharColumns);
 01120        }
 1121
 1122        public ref sbyte GetSbyteRef(int row, int column)
 01123        {
 01124            return ref GetCellRef(row, column, ref allSbyteColumns);
 01125        }
 1126
 1127        public ref byte GetByteRef(int row, int columnID)
 01128        {
 01129            return ref GetCellRef(row, columnID, ref allByteColumns);
 01130        }
 1131
 1132        public ref short GetShortRef(int row, int column)
 01133        {
 01134            return ref GetCellRef(row, column, ref allShortColumns);
 01135        }
 1136
 1137        public ref ushort GetUshortRef(int row, int column)
 01138        {
 01139            return ref GetCellRef(row, column, ref allUshortColumns);
 01140        }
 1141
 1142        public ref int GetIntRef(int row, int column)
 01143        {
 01144            return ref GetCellRef(row, column, ref allIntColumns);
 01145        }
 1146
 1147        public ref uint GetUintRef(int row, int column)
 01148        {
 01149            return ref GetCellRef(row, column, ref allUintColumns);
 01150        }
 1151
 1152        public ref long GetLongRef(int row, int column)
 01153        {
 01154            return ref GetCellRef(row, column, ref allLongColumns);
 01155        }
 1156
 1157        public ref ulong GetUlongRef(int row, int column)
 01158        {
 01159            return ref GetCellRef(row, column, ref allUlongColumns);
 01160        }
 1161
 1162        public ref float GetFloatRef(int row, int column)
 01163        {
 01164            return ref GetCellRef(row, column, ref allFloatColumns);
 01165        }
 1166
 1167        public ref double GetDoubleRef(int row, int column)
 01168        {
 01169            return ref GetCellRef(row, column, ref allDoubleColumns);
 01170        }
 1171
 1172        public ref Vector2 GetVector2Ref(int row, int column)
 01173        {
 01174            return ref GetCellRef(row, column, ref allVector2Columns);
 01175        }
 1176
 1177        public ref Vector3 GetVector3Ref(int row, int column)
 01178        {
 01179            return ref GetCellRef(row, column, ref allVector3Columns);
 01180        }
 1181
 1182        public ref Vector4 GetVector4Ref(int row, int column)
 01183        {
 01184            return ref GetCellRef(row, column, ref allVector4Columns);
 01185        }
 1186
 1187        public ref Vector2Int GetVector2IntRef(int row, int column)
 01188        {
 01189            return ref GetCellRef(row, column, ref allVector2IntColumns);
 01190        }
 1191
 1192        public ref Vector3Int GetVector3IntRef(int row, int column)
 01193        {
 01194            return ref GetCellRef(row, column, ref allVector3IntColumns);
 01195        }
 1196
 1197        public ref Quaternion GetQuaternionRef(int row, int column)
 01198        {
 01199            return ref GetCellRef(row, column, ref allQuaternionColumns);
 01200        }
 1201
 1202        public ref Rect GetRectRef(int row, int column)
 01203        {
 01204            return ref GetCellRef(row, column, ref allRectColumns);
 01205        }
 1206
 1207        public ref RectInt GetRectIntRef(int row, int column)
 01208        {
 01209            return ref GetCellRef(row, column, ref allRectIntColumns);
 01210        }
 1211
 1212        public ref Color GetColorRef(int row, int column)
 01213        {
 01214            return ref GetCellRef(row, column, ref allColorColumns);
 01215        }
 1216
 1217        public ref LayerMask GetLayerMaskRef(int row, int column)
 01218        {
 01219            return ref GetCellRef(row, column, ref allLayerMaskColumns);
 01220        }
 1221
 1222        public ref Bounds GetBoundsRef(int row, int column)
 01223        {
 01224            return ref GetCellRef(row, column, ref allBoundsColumns);
 01225        }
 1226
 1227        public ref BoundsInt GetBoundsIntRef(int row, int column)
 01228        {
 01229            return ref GetCellRef(row, column, ref allBoundsIntColumns);
 01230        }
 1231
 1232        public ref Hash128 GetHash128Ref(int row, int column)
 01233        {
 01234            return ref GetCellRef(row, column, ref allHash128Columns);
 01235        }
 1236
 1237        public ref Gradient GetGradientRef(int row, int column)
 01238        {
 01239            return ref GetCellRef(row, column, ref allGradientColumns);
 01240        }
 1241
 1242        public ref AnimationCurve GetAnimationCurveRef(int row, int column)
 01243        {
 01244            return ref GetCellRef(row, column, ref allAnimationCurveColumns);
 01245        }
 1246
 1247        public ref UnityEngine.Object GetObjectRef(int row, int column)
 01248        {
 01249            return ref GetCellRef(row, column, ref allObjectRefColumns);
 01250        }
 1251
 1252        // Get Column
 1253
 1254        public string[] GetStringColumn(int column)
 01255        {
 01256            return GetColumn(column, ref allStringColumns);
 01257        }
 1258
 1259        public bool[] GetBoolColumn(int column)
 01260        {
 01261            return GetColumn(column, ref allBoolColumns);
 01262        }
 1263
 1264        public char[] GetCharColumn(int column)
 01265        {
 01266            return GetColumn(column, ref allCharColumns);
 01267        }
 1268
 1269        public sbyte[] GetSbyteColumn(int column)
 01270        {
 01271            return GetColumn(column, ref allSbyteColumns);
 01272        }
 1273
 1274        public byte[] GetByteColumn(int column)
 01275        {
 01276            return GetColumn(column, ref allByteColumns);
 01277        }
 1278
 1279        public short[] GetShortColumn(int column)
 01280        {
 01281            return GetColumn(column, ref allShortColumns);
 01282        }
 1283
 1284        public ushort[] GetUshortColumn(int column)
 01285        {
 01286            return GetColumn(column, ref allUshortColumns);
 01287        }
 1288
 1289        public int[] GetIntColumn(int column)
 01290        {
 01291            return GetColumn(column, ref allIntColumns);
 01292        }
 1293
 1294        public uint[] GetUintColumn(int column)
 01295        {
 01296            return GetColumn(column, ref allUintColumns);
 01297        }
 1298
 1299        public long[] GetLongColumn(int column)
 01300        {
 01301            return GetColumn(column, ref allLongColumns);
 01302        }
 1303
 1304        public ulong[] GetUlongColumn(int column)
 01305        {
 01306            return GetColumn(column, ref allUlongColumns);
 01307        }
 1308
 1309        public float[] GetFloatColumn(int column)
 01310        {
 01311            return GetColumn(column, ref allFloatColumns);
 01312        }
 1313
 1314        public double[] GetDoubleColumn(int column)
 01315        {
 01316            return GetColumn(column, ref allDoubleColumns);
 01317        }
 1318
 1319        public Vector2[] GetVector2Column(int column)
 01320        {
 01321            return GetColumn(column, ref allVector2Columns);
 01322        }
 1323
 1324        public Vector3[] GetVector3Column(int column)
 01325        {
 01326            return GetColumn(column, ref allVector3Columns);
 01327        }
 1328
 1329        public Vector4[] GetVector4Column(int column)
 01330        {
 01331            return GetColumn(column, ref allVector4Columns);
 01332        }
 1333
 1334        public Vector2Int[] GetVector2IntColumn(int column)
 01335        {
 01336            return GetColumn(column, ref allVector2IntColumns);
 01337        }
 1338
 1339        public Vector3Int[] GetVector3IntColumn(int column)
 01340        {
 01341            return GetColumn(column, ref allVector3IntColumns);
 01342        }
 1343
 1344        public Quaternion[] GetQuaternionColumn(int column)
 01345        {
 01346            return GetColumn(column, ref allQuaternionColumns);
 01347        }
 1348
 1349        public Rect[] GetRectColumn(int column)
 01350        {
 01351            return GetColumn(column, ref allRectColumns);
 01352        }
 1353
 1354        public RectInt[] GetRectIntColumn(int column)
 01355        {
 01356            return GetColumn(column, ref allRectIntColumns);
 01357        }
 1358
 1359        public Color[] GetColorColumn(int column)
 01360        {
 01361            return GetColumn(column, ref allColorColumns);
 01362        }
 1363
 1364        public LayerMask[] GetLayerMaskColumn(int column)
 01365        {
 01366            return GetColumn(column, ref allLayerMaskColumns);
 01367        }
 1368
 1369        public Bounds[] GetBoundsColumn(int column)
 01370        {
 01371            return GetColumn(column, ref allBoundsColumns);
 01372        }
 1373
 1374        public BoundsInt[] GetBoundsIntColumn(int column)
 01375        {
 01376            return GetColumn(column, ref allBoundsIntColumns);
 01377        }
 1378
 1379        public Hash128[] GetHash128Column(int column)
 01380        {
 01381            return GetColumn(column, ref allHash128Columns);
 01382        }
 1383
 1384        public Gradient[] GetGradientColumn(int column)
 01385        {
 01386            return GetColumn(column, ref allGradientColumns);
 01387        }
 1388
 1389        public AnimationCurve[] GetAnimationCurveColumn(int column)
 01390        {
 01391            return GetColumn(column, ref allAnimationCurveColumns);
 01392        }
 1393
 1394        public UnityEngine.Object[] GetObjectColumn(int column)
 01395        {
 01396            return GetColumn(column, ref allObjectRefColumns);
 01397        }
 1398
 1399        // SetOrder
 1400
 1401        public void SetColumnOrder(int columnID, int newSortOrder)
 01402        {
 01403            AssertColumnIDValid(columnID);
 01404            AssertColumnSortOrderValid(newSortOrder);
 01405            int oldSortOrder = columnIDToSortOrderMap[columnID];
 01406            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01407            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01408            {
 01409                int columnIDAt = sortedOrderToColumnIDMap[i + iterDirection];
 01410                columnIDToSortOrderMap[columnIDAt] = i;
 01411                sortedOrderToColumnIDMap[i] = sortedOrderToColumnIDMap[i + iterDirection];
 01412            }
 1413
 01414            sortedOrderToColumnIDMap[newSortOrder] = columnID;
 01415            columnIDToSortOrderMap[columnID] = newSortOrder;
 01416        }
 1417
 1418        public void SetAllColumnOrders(int[] sortedColumnIDs)
 01419        {
 01420            AssertSortedColumnsArgValid(sortedColumnIDs);
 01421            for (int i = 0; i < sortedOrderToColumnIDMap.Length; i++)
 01422            {
 01423                int columnID = sortedColumnIDs[i];
 01424                sortedOrderToColumnIDMap[i] = columnID;
 01425                columnIDToSortOrderMap[columnID] = i;
 01426            }
 01427        }
 1428
 1429        public void SetRowOrder(int rowID, int newSortOrder)
 01430        {
 01431            AssertRowIDValid(rowID);
 01432            AssertRowSortOrderValid(newSortOrder);
 1433
 01434            int oldSortOrder = rowIDToDenseIndexMap[rowID];
 01435            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 1436
 01437            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01438            {
 01439                int rowIDAt = rowDenseIndexToIDMap[i + iterDirection];
 01440                rowIDToDenseIndexMap[rowIDAt] = i;
 01441                rowDenseIndexToIDMap[i] = rowDenseIndexToIDMap[i + iterDirection];
 01442            }
 1443
 01444            SetRowOrderForColumns(allStringColumns, oldSortOrder, newSortOrder);
 01445            SetRowOrderForColumns(allBoolColumns, oldSortOrder, newSortOrder);
 01446            SetRowOrderForColumns(allCharColumns, oldSortOrder, newSortOrder);
 01447            SetRowOrderForColumns(allSbyteColumns, oldSortOrder, newSortOrder);
 01448            SetRowOrderForColumns(allByteColumns, oldSortOrder, newSortOrder);
 01449            SetRowOrderForColumns(allShortColumns, oldSortOrder, newSortOrder);
 01450            SetRowOrderForColumns(allUshortColumns, oldSortOrder, newSortOrder);
 01451            SetRowOrderForColumns(allIntColumns, oldSortOrder, newSortOrder);
 01452            SetRowOrderForColumns(allUintColumns, oldSortOrder, newSortOrder);
 01453            SetRowOrderForColumns(allLongColumns, oldSortOrder, newSortOrder);
 01454            SetRowOrderForColumns(allUlongColumns, oldSortOrder, newSortOrder);
 01455            SetRowOrderForColumns(allFloatColumns, oldSortOrder, newSortOrder);
 01456            SetRowOrderForColumns(allDoubleColumns, oldSortOrder, newSortOrder);
 01457            SetRowOrderForColumns(allVector2Columns, oldSortOrder, newSortOrder);
 01458            SetRowOrderForColumns(allVector3Columns, oldSortOrder, newSortOrder);
 01459            SetRowOrderForColumns(allVector4Columns, oldSortOrder, newSortOrder);
 01460            SetRowOrderForColumns(allVector2IntColumns, oldSortOrder, newSortOrder);
 01461            SetRowOrderForColumns(allVector3IntColumns, oldSortOrder, newSortOrder);
 01462            SetRowOrderForColumns(allQuaternionColumns, oldSortOrder, newSortOrder);
 01463            SetRowOrderForColumns(allRectColumns, oldSortOrder, newSortOrder);
 01464            SetRowOrderForColumns(allRectIntColumns, oldSortOrder, newSortOrder);
 01465            SetRowOrderForColumns(allColorColumns, oldSortOrder, newSortOrder);
 01466            SetRowOrderForColumns(allLayerMaskColumns, oldSortOrder, newSortOrder);
 01467            SetRowOrderForColumns(allBoundsColumns, oldSortOrder, newSortOrder);
 01468            SetRowOrderForColumns(allBoundsIntColumns, oldSortOrder, newSortOrder);
 01469            SetRowOrderForColumns(allHash128Columns, oldSortOrder, newSortOrder);
 01470            SetRowOrderForColumns(allGradientColumns, oldSortOrder, newSortOrder);
 01471            SetRowOrderForColumns(allAnimationCurveColumns, oldSortOrder, newSortOrder);
 01472            SetRowOrderForColumns(allObjectRefColumns, oldSortOrder, newSortOrder);
 01473        }
 1474
 1475        public void SetAllRowOrders(int[] sortedRowIDs)
 01476        {
 01477            AssertSorteRowsArgValid(sortedRowIDs);
 1478
 01479            ReSortRows(allStringColumns, sortedRowIDs);
 01480            ReSortRows(allBoolColumns, sortedRowIDs);
 01481            ReSortRows(allCharColumns, sortedRowIDs);
 01482            ReSortRows(allSbyteColumns, sortedRowIDs);
 01483            ReSortRows(allByteColumns, sortedRowIDs);
 01484            ReSortRows(allShortColumns, sortedRowIDs);
 01485            ReSortRows(allUshortColumns, sortedRowIDs);
 01486            ReSortRows(allIntColumns, sortedRowIDs);
 01487            ReSortRows(allUintColumns, sortedRowIDs);
 01488            ReSortRows(allLongColumns, sortedRowIDs);
 01489            ReSortRows(allUlongColumns, sortedRowIDs);
 01490            ReSortRows(allFloatColumns, sortedRowIDs);
 01491            ReSortRows(allDoubleColumns, sortedRowIDs);
 01492            ReSortRows(allVector2Columns, sortedRowIDs);
 01493            ReSortRows(allVector3Columns, sortedRowIDs);
 01494            ReSortRows(allVector4Columns, sortedRowIDs);
 01495            ReSortRows(allVector2IntColumns, sortedRowIDs);
 01496            ReSortRows(allVector3IntColumns, sortedRowIDs);
 01497            ReSortRows(allQuaternionColumns, sortedRowIDs);
 01498            ReSortRows(allRectColumns, sortedRowIDs);
 01499            ReSortRows(allRectIntColumns, sortedRowIDs);
 01500            ReSortRows(allColorColumns, sortedRowIDs);
 01501            ReSortRows(allLayerMaskColumns, sortedRowIDs);
 01502            ReSortRows(allBoundsColumns, sortedRowIDs);
 01503            ReSortRows(allBoundsIntColumns, sortedRowIDs);
 01504            ReSortRows(allHash128Columns, sortedRowIDs);
 01505            ReSortRows(allGradientColumns, sortedRowIDs);
 01506            ReSortRows(allAnimationCurveColumns, sortedRowIDs);
 01507            ReSortRows(allObjectRefColumns, sortedRowIDs);
 1508
 01509            for (int i = 0; i < sortedRowIDs.Length; i++)
 01510            {
 01511                int rowID = sortedRowIDs[i];
 01512                rowDenseIndexToIDMap[i] = rowID;
 01513                rowIDToDenseIndexMap[rowID] = i;
 01514            }
 01515        }
 1516
 1517        internal void ReSortRows<T>(ArrayHolder<T>[] columns, int[] sortedRowIDs)
 01518        {
 01519            for (int i = 0; i < columns.Length; i++)
 01520            {
 01521                T[] column = columns[i].TArray;
 1522
 01523                for (int j = 0; j < sortedRowIDs.Length; j++)
 01524                {
 01525                    T rowValueAt = column[j];
 01526                    int rowID = sortedRowIDs[j];
 01527                    int oldRowIndex = rowIDToDenseIndexMap[rowID];
 1528
 01529                    column[j] = column[oldRowIndex];
 01530                    column[oldRowIndex] = rowValueAt;
 01531                }
 01532            }
 01533        }
 1534
 1535        // Internal
 1536
 1537        internal int AddColumnInternal<T>(string columnName, ref ArrayHolder<T>[] allColumnsOfType, Serializable.Seriali
 01538        {
 01539            if (insertAtColumnID >= 0)
 01540            {
 01541                AssertColumnIDValid(insertAtColumnID);
 01542            }
 01543            int columnCount = allColumnsOfType?.Length ?? 0;
 01544            Array.Resize(ref allColumnsOfType, columnCount + 1);
 01545            allColumnsOfType[columnCount].TArray = new T[rowCount];
 1546
 01547            int columnID = columnEntriesFreeListHead;
 01548            string[] columnNamesForType = allColumnNames[(int)typeIndex].TArray;
 01549            int columnNamesCount = columnNamesForType?.Length ?? 0;
 01550            Array.Resize(ref columnNamesForType, columnNamesCount + 1);
 01551            columnNamesForType[columnNamesCount] = columnName == null ? columnID.ToString() : columnName;
 01552            allColumnNames[(int)typeIndex].TArray = columnNamesForType;
 1553
 1554
 01555            int columnIDToDenseIndexMapLength = columnIDToDenseIndexMap?.Length ?? 0;
 01556            if (columnID >= columnIDToDenseIndexMapLength)
 01557            {
 01558                int newSize = columnIDToDenseIndexMapLength * 2;
 01559                newSize = newSize == 0 ? 1 : newSize;
 01560                Array.Resize(ref columnIDToDenseIndexMap, newSize);
 01561                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 01562                {
 01563                    ref ColumnEntry entry = ref columnIDToDenseIndexMap[i];
 01564                    entry.columnDenseIndex = i + 1;
 01565                    entry.ColumnType = Serializable.SerializableTypes.Invalid;
 01566                }
 1567
 01568                Array.Resize(ref columnIDToSortOrderMap, newSize);
 01569                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 01570                {
 01571                    columnIDToSortOrderMap[i] = -1;
 01572                }
 01573            }
 1574
 01575            columnEntriesFreeListHead = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 1576
 01577            ref int[] denseIndexToIDMap = ref columnDenseIndexToIDMap[(int)typeIndex].TArray;
 01578            int denseIndexToIDMapLength = denseIndexToIDMap?.Length ?? 0;
 01579            Array.Resize(ref denseIndexToIDMap, denseIndexToIDMapLength + 1);
 01580            denseIndexToIDMap[denseIndexToIDMapLength] = columnID;
 1581
 01582            ref ColumnEntry newEntry = ref columnIDToDenseIndexMap[columnID];
 01583            newEntry.columnDenseIndex = denseIndexToIDMapLength;
 01584            newEntry.ColumnType = typeIndex;
 1585
 01586            int insertAtSortedIndex = insertAtColumnID < 0 ? combinedColumnCount : columnIDToSortOrderMap[insertAtColumn
 01587            Array.Resize(ref sortedOrderToColumnIDMap, combinedColumnCount + 1);
 01588            for (int i = combinedColumnCount; i > insertAtSortedIndex; i--)
 01589            {
 01590                int currentColumnID = sortedOrderToColumnIDMap[i - 1];
 01591                sortedOrderToColumnIDMap[i] = currentColumnID;
 01592                columnIDToSortOrderMap[currentColumnID] = i;
 01593            }
 1594
 1595
 01596            columnIDToSortOrderMap[columnID] = insertAtSortedIndex;
 01597            sortedOrderToColumnIDMap[insertAtSortedIndex] = columnID;
 1598
 01599            ++combinedColumnCount;
 01600            dataVersion++;
 1601
 01602            return columnID;
 01603        }
 1604
 1605        internal void RemoveColumnInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, Serializable.SerializableTypes type
 01606        {
 01607            AssertColumnIDValid(columnID);
 01608            int columnLocation = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 1609
 01610            int lastIndex = allColumnsOfType.Length - 1;
 01611            allColumnsOfType[columnLocation] = allColumnsOfType[lastIndex];
 01612            Array.Resize(ref allColumnsOfType, lastIndex);
 1613
 01614            ref string[] columnNamesOfType = ref allColumnNames[(int)typeIndex].TArray;
 01615            columnNamesOfType[columnLocation] = columnNamesOfType[lastIndex];
 01616            Array.Resize(ref columnNamesOfType, lastIndex);
 1617
 01618            int columnOrder = columnIDToSortOrderMap[columnID];
 1619
 01620            ref int[] denseIndicesOfType = ref columnDenseIndexToIDMap[(int)typeIndex].TArray;
 01621            int sparseIndexToSwap = denseIndicesOfType[lastIndex];
 1622
 01623            ref ColumnEntry sparseIndexToFree = ref columnIDToDenseIndexMap[columnID];
 01624            sparseIndexToFree.ColumnType = Serializable.SerializableTypes.Invalid;
 01625            sparseIndexToFree.columnDenseIndex = columnEntriesFreeListHead;
 01626            columnEntriesFreeListHead = columnID;
 1627
 01628            columnIDToDenseIndexMap[sparseIndexToSwap].columnDenseIndex = columnLocation;
 01629            denseIndicesOfType[columnLocation] = sparseIndexToSwap;
 01630            Array.Resize(ref denseIndicesOfType, lastIndex);
 1631
 01632            for (int i = columnOrder + 1; i < combinedColumnCount; i++)
 01633            {
 01634                int currentColumnID = sortedOrderToColumnIDMap[i];
 01635                sortedOrderToColumnIDMap[i - 1] = currentColumnID;
 01636                columnIDToSortOrderMap[currentColumnID] = i - 1;
 01637            }
 1638
 01639            Array.Resize(ref sortedOrderToColumnIDMap, combinedColumnCount - 1);
 1640
 01641            --combinedColumnCount;
 01642            dataVersion++;
 01643        }
 1644
 1645        internal void InsertRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int insertAt, int numberOfNewRo
 01646        {
 01647            int columnCount = allColumnsOfType?.Length ?? 0;
 01648            for (int i = 0; i < columnCount; i++)
 01649            {
 01650                ref T[] rows = ref allColumnsOfType[i].TArray;
 01651                int newRowCount = rowCount + numberOfNewRows;
 01652                Array.Resize(ref rows, newRowCount);
 01653                for (int j = newRowCount - 1; j > insertAt + numberOfNewRows - 1; j--)
 01654                {
 01655                    rows[j] = rows[j - numberOfNewRows];
 01656                }
 1657
 01658                for (int j = 0; j < numberOfNewRows; j++)
 01659                {
 01660                    rows[insertAt + j] = default;
 01661                }
 01662            }
 01663        }
 1664
 1665        internal void DeleteRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int removeAt, int numberOfRowsT
 01666        {
 01667            int columnCount = allColumnsOfType?.Length ?? 0;
 1668
 01669            for (int i = 0; i < columnCount; i++)
 01670            {
 01671                ref T[] rows = ref allColumnsOfType[i].TArray;
 01672                int newRowCount = rowCount - numberOfRowsToDelete;
 1673
 01674                for (int j = removeAt + numberOfRowsToDelete; j < rowCount; j++)
 01675                {
 01676                    rows[j - numberOfRowsToDelete] = rows[j];
 01677                }
 1678
 01679                Array.Resize(ref rows, newRowCount);
 01680            }
 01681        }
 1682
 1683        internal ref T GetCellRef<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01684        {
 01685            AssertColumnIDValid(columnID);
 01686            AssertRowIDValid(rowID);
 01687            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01688            int row = rowIDToDenseIndexMap[rowID];
 01689            return ref allColumnsOfType[column][row];
 01690        }
 1691
 1692        internal T GetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01693        {
 01694            AssertColumnIDValid(columnID);
 01695            AssertRowIDValid(rowID);
 01696            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01697            int row = rowIDToDenseIndexMap[rowID];
 01698            return allColumnsOfType[column][row];
 01699        }
 1700
 1701        internal ulong SetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType, T value)
 01702        {
 01703            AssertColumnIDValid(columnID);
 01704            AssertRowIDValid(rowID);
 01705            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01706            int row = rowIDToDenseIndexMap[rowID];
 01707            allColumnsOfType[column][row] = value;
 01708            dataVersion++;
 01709            return dataVersion;
 01710        }
 1711
 1712        internal T[] GetColumn<T>(int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01713        {
 01714            AssertColumnIDValid(columnID);
 01715            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01716            return allColumnsOfType[column].TArray;
 01717        }
 1718
 1719        internal void SetRowOrderForColumns<T>(ArrayHolder<T>[] columns, int oldSortOrder, int newSortOrder)
 01720        {
 01721            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01722            for (int i = 0; i < columns.Length; i++)
 01723            {
 01724                T[] column = columns[i].TArray;
 1725
 01726                for (int j = oldSortOrder; j != newSortOrder; j += iterDirection)
 01727                {
 01728                    column[j] = column[j + iterDirection];
 01729                }
 01730            }
 01731        }
 1732
 1733        internal void AssertSortedColumnsArgValid(int[] sortedColumnIDs)
 01734        {
 01735            if (sortedColumnIDs == null)
 01736            {
 01737                throw new ArgumentException("sortedColumnIDs array cannot be null.");
 1738            }
 1739
 01740            if (sortedColumnIDs.Length != sortedOrderToColumnIDMap.Length)
 01741            {
 01742                throw new ArgumentException("sortedColumnIDs array must be the same length as GetColumnCount.");
 1743            }
 1744
 01745            for (int i = 0; i < sortedColumnIDs.Length; i++)
 01746            {
 01747                AssertColumnIDValid(sortedColumnIDs[i]);
 01748            }
 01749        }
 1750
 1751        internal void AssertColumnSortOrderValid(int sortedOrder)
 01752        {
 01753            if (sortedOrder >= combinedColumnCount || sortedOrder < 0)
 01754            {
 01755                throw new ArgumentException("Invalid column sort order argument: " + sortedOrder);
 1756            }
 01757        }
 1758
 1759        internal void AssertRowSortOrderValid(int sortedOrder)
 01760        {
 01761            if (sortedOrder >= rowCount || sortedOrder < 0)
 01762            {
 01763                throw new ArgumentException("Invalid row sort order argument: " + sortedOrder);
 1764            }
 01765        }
 1766
 1767        internal void AssertSorteRowsArgValid(int[] sortedRowIDs)
 01768        {
 01769            if (sortedRowIDs == null)
 01770            {
 01771                throw new ArgumentException("sortedRowIDs array cannot be null.");
 1772            }
 1773
 01774            if (sortedRowIDs.Length != rowDenseIndexToIDMap.Length)
 01775            {
 01776                throw new ArgumentException("sortedRowIDs array must be the same length as GetRowCount.");
 1777            }
 1778
 01779            for (int i = 0; i < sortedRowIDs.Length; i++)
 01780            {
 01781                AssertRowIDValid(sortedRowIDs[i]);
 01782            }
 01783        }
 1784    }
 1785}

Coverage by test methods





































































































































































































































































































































































































































































































































































































































































































Methods/Properties

StableTable()
GetDataVersion()
GetColumnCount()
GetRowCount()
GetDisplayName()
SetDisplayName(System.String)
GetFlag(System.Byte)
SetFlag(System.Byte, System.Boolean)
GetAllRowDescriptions()
GetRowDescription(System.String)
GetRowDescription(System.Int32)
SetAllRowDescriptionsOrder(GDX.Tables.ITable/RowDescription[])
GetColumnDescription(System.String)
GetColumnDescription(System.Int32)
SetAllColumnDescriptionsOrder(GDX.Tables.ITable/ColumnDescription[])
GetAllColumnDescriptions()
AssertColumnIDValid(System.Int32)
AssertRowIDValid(System.Int32)
SetColumnName(System.String, System.Int32)
GetColumnName(System.Int32)
SetRowName(System.String, System.Int32)
GetRowName(System.Int32)
GetRowNameRef(System.Int32)
GetColumnNameRef(System.Int32)
AddRow(System.String, System.Int32)
AddRows(System.Int32, System.String[], System.Int32)
AddRows(System.Int32, System.Int32[]&, System.String[], System.Int32)
RemoveRow(System.Int32)
AddColumn(GDX.Serializable/SerializableTypes, System.String, System.Int32)
RemoveColumn(GDX.Serializable/SerializableTypes, System.Int32)
SetString(System.Int32, System.Int32, System.String)
SetBool(System.Int32, System.Int32, System.Boolean)
SetChar(System.Int32, System.Int32, System.Char)
SetSByte(System.Int32, System.Int32, System.SByte)
SetByte(System.Int32, System.Int32, System.Byte)
SetShort(System.Int32, System.Int32, System.Int16)
SetUShort(System.Int32, System.Int32, System.UInt16)
SetInt(System.Int32, System.Int32, System.Int32)
SetUInt(System.Int32, System.Int32, System.UInt32)
SetLong(System.Int32, System.Int32, System.Int64)
SetULong(System.Int32, System.Int32, System.UInt64)
SetFloat(System.Int32, System.Int32, System.Single)
SetDouble(System.Int32, System.Int32, System.Double)
SetVector2(System.Int32, System.Int32, UnityEngine.Vector2)
SetVector3(System.Int32, System.Int32, UnityEngine.Vector3)
SetVector4(System.Int32, System.Int32, UnityEngine.Vector4)
SetVector2Int(System.Int32, System.Int32, UnityEngine.Vector2Int)
SetVector3Int(System.Int32, System.Int32, UnityEngine.Vector3Int)
SetQuaternion(System.Int32, System.Int32, UnityEngine.Quaternion)
SetRect(System.Int32, System.Int32, UnityEngine.Rect)
SetRectInt(System.Int32, System.Int32, UnityEngine.RectInt)
SetColor(System.Int32, System.Int32, UnityEngine.Color)
SetLayerMask(System.Int32, System.Int32, UnityEngine.LayerMask)
SetBounds(System.Int32, System.Int32, UnityEngine.Bounds)
SetBoundsInt(System.Int32, System.Int32, UnityEngine.BoundsInt)
SetHash128(System.Int32, System.Int32, UnityEngine.Hash128)
SetGradient(System.Int32, System.Int32, UnityEngine.Gradient)
SetAnimationCurve(System.Int32, System.Int32, UnityEngine.AnimationCurve)
SetObject(System.Int32, System.Int32, UnityEngine.Object)
GetString(System.Int32, System.Int32)
GetBool(System.Int32, System.Int32)
GetChar(System.Int32, System.Int32)
GetSByte(System.Int32, System.Int32)
GetByte(System.Int32, System.Int32)
GetShort(System.Int32, System.Int32)
GetUShort(System.Int32, System.Int32)
GetInt(System.Int32, System.Int32)
GetUInt(System.Int32, System.Int32)
GetLong(System.Int32, System.Int32)
GetULong(System.Int32, System.Int32)
GetFloat(System.Int32, System.Int32)
GetDouble(System.Int32, System.Int32)
GetVector2(System.Int32, System.Int32)
GetVector3(System.Int32, System.Int32)
GetVector4(System.Int32, System.Int32)
GetVector2Int(System.Int32, System.Int32)
GetVector3Int(System.Int32, System.Int32)
GetQuaternion(System.Int32, System.Int32)
GetRect(System.Int32, System.Int32)
GetRectInt(System.Int32, System.Int32)
GetColor(System.Int32, System.Int32)
GetLayerMask(System.Int32, System.Int32)
GetBounds(System.Int32, System.Int32)
GetBoundsInt(System.Int32, System.Int32)
GetHash128(System.Int32, System.Int32)
GetGradient(System.Int32, System.Int32)
GetAnimationCurve(System.Int32, System.Int32)
GetObject(System.Int32, System.Int32)
GetStringRef(System.Int32, System.Int32)
GetBoolRef(System.Int32, System.Int32)
GetCharRef(System.Int32, System.Int32)
GetSbyteRef(System.Int32, System.Int32)
GetByteRef(System.Int32, System.Int32)
GetShortRef(System.Int32, System.Int32)
GetUshortRef(System.Int32, System.Int32)
GetIntRef(System.Int32, System.Int32)
GetUintRef(System.Int32, System.Int32)
GetLongRef(System.Int32, System.Int32)
GetUlongRef(System.Int32, System.Int32)
GetFloatRef(System.Int32, System.Int32)
GetDoubleRef(System.Int32, System.Int32)
GetVector2Ref(System.Int32, System.Int32)
GetVector3Ref(System.Int32, System.Int32)
GetVector4Ref(System.Int32, System.Int32)
GetVector2IntRef(System.Int32, System.Int32)
GetVector3IntRef(System.Int32, System.Int32)
GetQuaternionRef(System.Int32, System.Int32)
GetRectRef(System.Int32, System.Int32)
GetRectIntRef(System.Int32, System.Int32)
GetColorRef(System.Int32, System.Int32)
GetLayerMaskRef(System.Int32, System.Int32)
GetBoundsRef(System.Int32, System.Int32)
GetBoundsIntRef(System.Int32, System.Int32)
GetHash128Ref(System.Int32, System.Int32)
GetGradientRef(System.Int32, System.Int32)
GetAnimationCurveRef(System.Int32, System.Int32)
GetObjectRef(System.Int32, System.Int32)
GetStringColumn(System.Int32)
GetBoolColumn(System.Int32)
GetCharColumn(System.Int32)
GetSbyteColumn(System.Int32)
GetByteColumn(System.Int32)
GetShortColumn(System.Int32)
GetUshortColumn(System.Int32)
GetIntColumn(System.Int32)
GetUintColumn(System.Int32)
GetLongColumn(System.Int32)
GetUlongColumn(System.Int32)
GetFloatColumn(System.Int32)
GetDoubleColumn(System.Int32)
GetVector2Column(System.Int32)
GetVector3Column(System.Int32)
GetVector4Column(System.Int32)
GetVector2IntColumn(System.Int32)
GetVector3IntColumn(System.Int32)
GetQuaternionColumn(System.Int32)
GetRectColumn(System.Int32)
GetRectIntColumn(System.Int32)
GetColorColumn(System.Int32)
GetLayerMaskColumn(System.Int32)
GetBoundsColumn(System.Int32)
GetBoundsIntColumn(System.Int32)
GetHash128Column(System.Int32)
GetGradientColumn(System.Int32)
GetAnimationCurveColumn(System.Int32)
GetObjectColumn(System.Int32)
SetColumnOrder(System.Int32, System.Int32)
SetAllColumnOrders(System.Int32[])
SetRowOrder(System.Int32, System.Int32)
SetAllRowOrders(System.Int32[])
ReSortRows[T](, System.Int32[])
AddColumnInternal[T](System.String, , GDX.Serializable/SerializableTypes, System.Int32)
RemoveColumnInternal[T](, GDX.Serializable/SerializableTypes, System.Int32)
InsertRowsOfTypeInternal[T](, System.Int32, System.Int32)
DeleteRowsOfTypeInternal[T](, System.Int32, System.Int32)
GetCellRef[T](System.Int32, System.Int32, )
GetCell[T](System.Int32, System.Int32, )
SetCell[T](System.Int32, System.Int32, , T)
GetColumn[T](System.Int32, )
SetRowOrderForColumns[T](, System.Int32, System.Int32)
AssertSortedColumnsArgValid(System.Int32[])
AssertColumnSortOrderValid(System.Int32)
AssertRowSortOrderValid(System.Int32)
AssertSorteRowsArgValid(System.Int32[])